package principal;

import edu.uci.ics.jung.graph.DirectedGraph;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.io.*;
import java.util.ArrayList;
import javax.swing.*;
import misc.Printing;
import misc.Sorting;
import model.Aluno;
import model.Popularidade;

public class Principal extends javax.swing.JFrame {
    
    private final File arquivo_rm = new File("alunos_rm");
    private final File arquivo_nome = new File("alunos_nome");
    
    private ArrayList<Integer> lista_rm = new ArrayList<Integer>();
    
    private ArrayList<Aluno> alunos_rm = new ArrayList<Aluno>();
    private ArrayList<Aluno> alunos_nome = new ArrayList<Aluno>();
    
    private ArrayList<Popularidade> popularidade = new ArrayList<Popularidade>();
    
    private DirectedGraph<String, String> g = null;
    
    private boolean carregar_tudo = false;
    private boolean grafo_rm = false;
    
    Sorting sort = new Sorting();
    Printing print = new Printing();

    public Principal() {
        initComponents();
        this.setLocationRelativeTo(null);
        
        keystrokes();
    }
    
    public Principal(ArrayList<Integer> lista_rm, ArrayList<Aluno> alunos_rm, ArrayList<Aluno> alunos_nome, DirectedGraph<String, String> g, boolean grafo_rm) {
        initComponents();
        this.setLocationRelativeTo(null);
        
        this.lista_rm = lista_rm;
        this.alunos_rm = alunos_rm;
        this.alunos_nome = alunos_nome;
        this.g = g;
        
        this.grafo_rm = grafo_rm;
        
        keystrokes();
    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        btnCarregarArquivo = new javax.swing.JButton();
        btnCarregarAlunos = new javax.swing.JButton();
        btnCarregarNomes = new javax.swing.JButton();
        btnCarregarTudo = new javax.swing.JButton();
        btnListarAlunos = new javax.swing.JButton();
        btnPesquisarApontamentos = new javax.swing.JButton();
        btnConexoes = new javax.swing.JButton();
        btnListarPopularidade = new javax.swing.JButton();
        btnGrafoRMs = new javax.swing.JButton();
        btnGrafoNomes = new javax.swing.JButton();
        btnExibirGrafo = new javax.swing.JButton();
        btnSair = new javax.swing.JButton();
        btnMenorCaminho = new javax.swing.JButton();
        btnNaoAlcancaveis = new javax.swing.JButton();
        btnQtdeMax = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Projeto Rede Social");
        setResizable(false);

        btnCarregarArquivo.setText("Carregar Arquivo - RM's");
        btnCarregarArquivo.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnCarregarArquivoActionPerformed(evt);
            }
        });

        btnCarregarAlunos.setText("Carregar Alunos");
        btnCarregarAlunos.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnCarregarAlunosActionPerformed(evt);
            }
        });

        btnCarregarNomes.setText("Carregar Nomes");
        btnCarregarNomes.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnCarregarNomesActionPerformed(evt);
            }
        });

        btnCarregarTudo.setText("Carregar Tudo");
        btnCarregarTudo.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnCarregarTudoActionPerformed(evt);
            }
        });

        btnListarAlunos.setText("Listar Alunos");
        btnListarAlunos.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnListarAlunosActionPerformed(evt);
            }
        });

        btnPesquisarApontamentos.setText("Exibir Apontamentos");
        btnPesquisarApontamentos.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnPesquisarApontamentosActionPerformed(evt);
            }
        });

        btnConexoes.setText("Exibir Conexões Próx.");
        btnConexoes.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnConexoesActionPerformed(evt);
            }
        });

        btnListarPopularidade.setText("Listar Popularidade");
        btnListarPopularidade.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnListarPopularidadeActionPerformed(evt);
            }
        });

        btnGrafoRMs.setText("Criar Grafo - RM's");
        btnGrafoRMs.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnGrafoRMsActionPerformed(evt);
            }
        });

        btnGrafoNomes.setText("Criar Grafo - Nomes");
        btnGrafoNomes.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnGrafoNomesActionPerformed(evt);
            }
        });

        btnExibirGrafo.setText("Exibir Grafo");
        btnExibirGrafo.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnExibirGrafoActionPerformed(evt);
            }
        });

        btnSair.setText("Sair");
        btnSair.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnSairActionPerformed(evt);
            }
        });

        btnMenorCaminho.setText("Exibir Menor Caminho");
        btnMenorCaminho.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnMenorCaminhoActionPerformed(evt);
            }
        });

        btnNaoAlcancaveis.setText("Listar Não Alcançáveis");
        btnNaoAlcancaveis.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnNaoAlcancaveisActionPerformed(evt);
            }
        });

        btnQtdeMax.setText("Listar Qtde. Máxima");
        btnQtdeMax.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnQtdeMaxActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(btnQtdeMax, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                    .addComponent(btnExibirGrafo, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                    .addComponent(btnSair, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                    .addGroup(layout.createSequentialGroup()
                        .addComponent(btnCarregarNomes, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(btnCarregarTudo, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
                    .addGroup(layout.createSequentialGroup()
                        .addGap(0, 0, Short.MAX_VALUE)
                        .addComponent(btnMenorCaminho, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(btnNaoAlcancaveis, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE))
                    .addGroup(layout.createSequentialGroup()
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                            .addGroup(layout.createSequentialGroup()
                                .addComponent(btnCarregarArquivo, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                .addComponent(btnCarregarAlunos, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE))
                            .addGroup(layout.createSequentialGroup()
                                .addComponent(btnListarAlunos, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                .addComponent(btnPesquisarApontamentos, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE))
                            .addGroup(layout.createSequentialGroup()
                                .addComponent(btnConexoes, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                .addComponent(btnListarPopularidade, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE))
                            .addGroup(layout.createSequentialGroup()
                                .addComponent(btnGrafoRMs, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                .addComponent(btnGrafoNomes, javax.swing.GroupLayout.PREFERRED_SIZE, 180, javax.swing.GroupLayout.PREFERRED_SIZE)))
                        .addGap(0, 0, Short.MAX_VALUE)))
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(btnCarregarArquivo)
                    .addComponent(btnCarregarAlunos))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(btnCarregarNomes)
                    .addComponent(btnCarregarTudo))
                .addGap(18, 18, 18)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(btnListarAlunos)
                    .addComponent(btnPesquisarApontamentos))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(btnConexoes)
                    .addComponent(btnListarPopularidade))
                .addGap(18, 18, 18)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(btnGrafoRMs)
                    .addComponent(btnGrafoNomes))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(btnExibirGrafo)
                .addGap(18, 18, 18)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(btnMenorCaminho)
                    .addComponent(btnNaoAlcancaveis))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(btnQtdeMax)
                .addGap(18, 18, 18)
                .addComponent(btnSair)
                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>//GEN-END:initComponents

    private void btnCarregarArquivoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnCarregarArquivoActionPerformed
        carregar_arquivo();
    }//GEN-LAST:event_btnCarregarArquivoActionPerformed

    private void btnCarregarAlunosActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnCarregarAlunosActionPerformed
        carregar_alunos();
    }//GEN-LAST:event_btnCarregarAlunosActionPerformed

    private void btnCarregarNomesActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnCarregarNomesActionPerformed
        carregar_nomes();
    }//GEN-LAST:event_btnCarregarNomesActionPerformed

    private void btnCarregarTudoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnCarregarTudoActionPerformed
        carregar_tudo = true;
        carregar_arquivo();
        carregar_alunos();
        carregar_nomes();
        carregar_tudo = false;
        if(!lista_rm.isEmpty() && !alunos_rm.isEmpty() && !alunos_nome.isEmpty()) {
            msg_sucesso("Carregar Tudo: Sucesso!");
        }
    }//GEN-LAST:event_btnCarregarTudoActionPerformed

    private void btnListarAlunosActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnListarAlunosActionPerformed
        listar_alunos();
    }//GEN-LAST:event_btnListarAlunosActionPerformed

    private void btnPesquisarApontamentosActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnPesquisarApontamentosActionPerformed
        exibir_apontamentos();
    }//GEN-LAST:event_btnPesquisarApontamentosActionPerformed

    private void btnSairActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnSairActionPerformed
        System.exit(0);
    }//GEN-LAST:event_btnSairActionPerformed

    private void btnListarPopularidadeActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnListarPopularidadeActionPerformed
        listar_popularidade();
    }//GEN-LAST:event_btnListarPopularidadeActionPerformed

    private void btnConexoesActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnConexoesActionPerformed
        exibir_conexoes_proximas();
    }//GEN-LAST:event_btnConexoesActionPerformed

    private void btnGrafoRMsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnGrafoRMsActionPerformed
        criar_grafo_rm();
    }//GEN-LAST:event_btnGrafoRMsActionPerformed

    private void btnGrafoNomesActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnGrafoNomesActionPerformed
        criar_grafo_nome();
    }//GEN-LAST:event_btnGrafoNomesActionPerformed

    private void btnExibirGrafoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnExibirGrafoActionPerformed
        exibir_grafo();
    }//GEN-LAST:event_btnExibirGrafoActionPerformed

    private void btnMenorCaminhoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnMenorCaminhoActionPerformed
        exibir_menor_caminho();
    }//GEN-LAST:event_btnMenorCaminhoActionPerformed

    private void btnNaoAlcancaveisActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnNaoAlcancaveisActionPerformed
        listar_nao_alcancaveis();
    }//GEN-LAST:event_btnNaoAlcancaveisActionPerformed

    private void btnQtdeMaxActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnQtdeMaxActionPerformed
        listar_qtde_maxima();
    }//GEN-LAST:event_btnQtdeMaxActionPerformed

    /*********************
     * MÉTODOS -  GERAIS *
     *********************/
    
    // Fecha tela com ESC
    private void keystrokes() {
        KeyStroke escapeKeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0, false);
        Action escapeAction = new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
               dispose();
            }  
        };
        
        this.getRootPane().getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(escapeKeyStroke, "ESCAPE");
        this.getRootPane().getActionMap().put("ESCAPE", escapeAction);
    }
    
    // Carrega Lista de RM's e coloca no ArrayList alunos_rm:
    private void carregar_arquivo() {
        if(!arquivo_rm.exists()) {
            msg_erro("Arquivo com lista de RM's não existe!");
        }
        else {
            lista_rm.clear(); // Caso o método seja chamado mais de uma vez, necessário limpar o ArrayList primeiro
            String linha = "";
            try {
                BufferedReader br = new BufferedReader(new FileReader(arquivo_rm)); // Lê cada linha do arquivo e adiciona numa posição do ArrayList
                while((linha = br.readLine()) != null) {
                    lista_rm.add(Integer.parseInt(linha));
                }
                br.close();
                
                if(lista_rm.isEmpty()) {
                    msg_erro("Arquivo com lista de RM's parece estar em branco!");
                }
                else {
                    boolean validar = true;
                    for(int cont = 0 ; cont < lista_rm.size() && validar ; cont++) {
                        if(lista_rm.get(cont) < 10000 || lista_rm.get(cont) > 99999) {
                             msg_erro("Existe uma entrada inválida no arquivo de RM's: " + String.valueOf(lista_rm.get(cont)));
                             validar = false;
                        }
                    }
                    if(!validar) {
                        lista_rm.clear();
                    }
                    else {
                        System.out.println("\n# RM's - Carregados: #\n");
                        print.imprimir_lista_rm(lista_rm);
                        
                        sort.setLista_rm(lista_rm);
                        sort.quicksort_lista_rm(0, lista_rm.size()-1); // Ordena a Lista por Quick Sort + Insertion Sort
                        lista_rm = sort.getLista_rm();
                        
                        System.out.println("\n# RM's - Ordenados: #\n");
                        print.imprimir_lista_rm(lista_rm);
                        
                        if(!carregar_tudo) { // Apenas não exibe a mensagem de sucesso se foi clicado no botão "Carregar Tudo"
                            msg_sucesso("Carregar Arquivo - RM's: Sucesso!");
                        }
                    }
                }
            }
            catch(FileNotFoundException e) {
                msg_erro("Erro ao ler arquivo de RM's: " + e);
                lista_rm.clear();
            }
            catch(IOException e ) {
                msg_erro("Erro ao ler arquivo de RM's: " + e);
                lista_rm.clear();
            }
            catch(NumberFormatException e) {
                msg_erro("Existe uma entrada inválida no arquivo de RM's: " + linha);
                lista_rm.clear();
            }
        }
    }
    
    // Carrega o ArrayList alunos com os RM's dos alunos e suas conexões:
    private void carregar_alunos() {
        if(lista_rm.isEmpty()) {
            msg_aviso("Carregue o Arquivo de RM's primeiro!");
        }
        else {
            alunos_rm.clear();
            String so = System.getProperty("os.name").toLowerCase();
            String barra;
            if(so.contains("win")) { // Windows ou Linux para '\' ou '/' na hora de localizar os arquivos .txt
                barra = "\\";
            }
            else {
                barra = "/";
            }
            System.out.println("\n# Sistema Operacional: " + so + " | Usando barra para diretórios: " + barra + " #\n");
            File f;
            boolean validar = true;
            for(int k = 0 ; k < lista_rm.size() && validar ; k++) {
                f = new File("dados" + barra + lista_rm.get(k) + ".txt"); // Localiza o arquivo .txt
                if(!f.exists()) {
                    msg_erro("Arquivo não existe: " + String.valueOf(f));
                    validar = false;
                    alunos_rm.clear();
                }
                else {
                    try {
                        System.out.println("Arquivo Carregado: " + String.valueOf(f));
                        
                        // Insere o RM e o Nome (Nome = RM até métodos posteriores):
                        Aluno a = new Aluno();
                        a.setRm(lista_rm.get(k));
                        a.setNome("RM " + String.valueOf(lista_rm.get(k)));
                        
                        /* Lê o arquivo e Separa as linhas no formato:
                         * RM1,RM2,RM3, ...*/
                        String linha_rms = organizar_linha_rms(f);
                        
                        // Insere as conexões do aluno:
                        Integer[] conexoes_rm = new Integer[a.getLimite_vetor()];
                        String[] conexoes_nome = new String[a.getLimite_vetor()];
                        int index = 0;
                        for(int l = 0 ; l < linha_rms.length() ; l++) {
                            if(linha_rms.charAt(l) == ',') {
                                conexoes_rm[index] = Integer.parseInt(linha_rms.substring(l-5, l)); // Últimos 5 digitos antes da ',' = RM
                                index++;
                            }
                        }
                        
                        /* conexoes_rm e conexoes_nome não terão valores nulos.
                         * conexoes_nome recebe em cada posição o valor dos RM's correspondentes: */
                        for(int l = 0 ; l < a.getLimite_vetor() ; l++) {
                            if(conexoes_rm[l] == null) {
                                conexoes_rm[l] = 0;
                                conexoes_nome[l] = "";
                            }
                            else {
                                conexoes_nome[l] = String.valueOf(conexoes_rm[l]);
                            }
                        }
                        
                        // Termina de setar as propridades do Objeto Aluno e grava no ArrayList:
                        a.setConexoes_rm(conexoes_rm);
                        a.setConexoes_nome(conexoes_nome);

                        alunos_rm.add(a);
                        
                    }
                    catch(NumberFormatException e) {
                        msg_erro("Problemas ao converter dados do Arquivo:" + String.valueOf(f) + "\n\n" + String.valueOf(e));
                        validar = false;
                        alunos_rm.clear();
                    }
                    catch(FileNotFoundException e) {
                        msg_erro("Problemas ao ler Arquivo: " + String.valueOf(f) + "\n\n" + String.valueOf(e));
                        validar = false;
                        alunos_rm.clear();
                    }
                    catch(IOException e) {
                        msg_erro("Problemas ao ler Arquivo: " + String.valueOf(f) + "\n\n" + String.valueOf(e));
                        validar = false;
                        alunos_rm.clear();
                    }
                    catch(ArrayIndexOutOfBoundsException e) {
                        msg_erro("Problemas ao ler Arquivo: " + String.valueOf(f) + "\n\n" + String.valueOf(e));
                        validar = false;
                        alunos_rm.clear();
                    }
                    catch(StringIndexOutOfBoundsException e) {
                        msg_erro("Problemas ao ler Arquivo: " + String.valueOf(f) + "\n\n" + String.valueOf(e));
                        validar = false;
                        alunos_rm.clear();
                    }
                }
            }
            if(!alunos_rm.isEmpty()) { // Se qualquer erro ocorreu, o Array foi limpo. Senão, deu tudo certo.
                inserir_todos_os_rms(); // Insere todos os RM's, inclusive os que não apontaram ninguém
                
                sort.setAlunos_rm(alunos_rm);
                long startTime = System.nanoTime();
                sort.insertion_sort_alunos_rm(); // Ordena a Nova Lista de RM's (inserir_todos) por Insertion Sort
                long endTime = System.nanoTime();
                float duracao = (endTime - startTime) / 1000000.0f; // Duração do método
                alunos_rm = sort.getAlunos_rm();
                
                System.out.println("\n\n# Alunos - Ordenados por RM: #");
                print.imprimir_alunos_rm(alunos_rm);
                System.out.println("\n\n# Insertion Sort - Duração: " + String.valueOf(duracao) + "ms (partes do Array pré-ordenadas) #");
                
                if(!carregar_tudo) {
                    msg_sucesso("Carregar Alunos: Sucesso!");
                }
            }
        }
    }
    
    /* Lê o arquivo e Separa as linhas no formato:
     * RM1,RM2,RM3, ...*/
    private String organizar_linha_rms(File f) throws FileNotFoundException, IOException, ArrayIndexOutOfBoundsException, StringIndexOutOfBoundsException {
        String linha;
        
        BufferedReader br = new BufferedReader(new FileReader(f));
        
        // Se possuir mais de uma linha, separa em somente uma, garantindo vírgulas entre os RM's:
        ArrayList<String> array_rms = new ArrayList<String>();
        while((linha = br.readLine()) != null) {
            if(!linha.contains(",")) {
                linha += ",";
            }
            array_rms.add(linha);
        }
        br.close();
        linha = "";
        for(int k = 0 ; k < array_rms.size() ; k++) {
            linha += array_rms.get(k);
        }
        
        // Coloca uma vírgula no final para separar o último RM:
        if(linha.charAt(linha.length() - 1) != ',') {
            linha += ",";
        }
        
        // Tira os espaços e tabs da linha:
        char[] linha_char = linha.toCharArray();
        ArrayList<Character> linha_character = new ArrayList<Character>();
        for(Character c : linha_char) {
            if(c != ' ' && c != '\t') {
                linha_character.add(c);
            }
        }
        linha = "";
        for(Character c : linha_character) {
            if(c != ' ' && c != '\t') {
                linha += c.toString();
            }
        }
        
    return(linha);
    }
    
    // Insere todos os RM's, inclusive os que não criaram arquivos:
    private void inserir_todos_os_rms() {
            
        // Insere em todos_rms todos os RM's apontados:
        ArrayList<Integer> todos_rms = new ArrayList<Integer>();

        for(Aluno a : alunos_rm) {
            Integer[] conexoes_rm = a.getConexoes_rm();
            for(Integer rm : conexoes_rm) {
                if(rm != 0) {
                    todos_rms.add(rm);
                }
            }
        }

        // Verifica somente os que não existem ainda e insere em rms_nao_existem:
        ArrayList<Integer> rms_nao_existem = new ArrayList<Integer>();
        for(Integer rm : todos_rms) {
            boolean existe = false;
            for(Integer aluno_rm : lista_rm) {
                if(rm - aluno_rm == 0) {
                    existe = true;
                }
            }
            if(!existe && !rms_nao_existem.isEmpty()) {
                for(Integer aluno_rm : rms_nao_existem) {
                    if(rm - aluno_rm == 0) {
                        existe = true;
                    }
                }
            }
            if(!existe) {
                rms_nao_existem.add(rm);
            }
        }
        
        // Popula o ArrayList alunos com os que não existem:
        for(Integer rm : rms_nao_existem) {
            Aluno a = new Aluno();
            a.setRm(rm);
            a.setNome(String.valueOf(rm));
            alunos_rm.add(a);
        }
        
    }
    
    // Lê o arquivo com nomes e carrega o nome adequado para cada RM:
    private void carregar_nomes() {
        if(alunos_rm.isEmpty()) {
            msg_aviso("Carregue os Alunos primeiro!");
        }
        else if(!arquivo_nome.exists()) {
            msg_aviso("Arquivo de nomes não existe!");
        }
        else {
            try {
                alunos_nome.clear();
                
                BufferedReader br = new BufferedReader(new FileReader(arquivo_nome));
                ArrayList<String> nomes = new ArrayList<String>();
                String linha;
                while((linha = br.readLine()) != null) {
                    nomes.add(linha);
                }
                br.close();
                
                // Procura por ocorrências no ArrayList de Nomes para cada RM:
                for(Aluno a : alunos_rm) {
                    a.setNome(retornar_nome(nomes, a.getRm()));
                    String[] conexoes_nome = a.getConexoes_nome();
                    Integer[] conexoes_rm = a.getConexoes_rm();
                    for(int k = 0 ; k < conexoes_nome.length ; k++) {
                        if(!("".equals(conexoes_nome[k]))) {
                            conexoes_nome[k] = retornar_nome(nomes, conexoes_rm[k]);
                        }
                    }
                    
                    a.setConexoes_nome(conexoes_nome);
                }
                
                // Copia o ArayList de RM's para o ArrayList de Nomes:
                for(Aluno a : alunos_rm) {
                    alunos_nome.add(a);
                }
                
                sort.setAlunos_nome(alunos_nome);
                long startTime = System.nanoTime();
                sort.selection_sort_alunos_nome(); // Ordena o ArrayList alunos_nome por Selection Sort
                long endTime = System.nanoTime();
                float duracao = (endTime - startTime) / 1000000.0f;
                alunos_nome = sort.getAlunos_nome();
                
                System.out.println("\n\n# Alunos - Ordenados por Nome: #");
                print.imprimir_alunos_nome(alunos_nome);
                System.out.println("\n\n# Selection Sort - Duração: " + String.valueOf(duracao) + "ms #");
                
                if(!carregar_tudo) {
                    msg_sucesso("Carregar Nomes: Sucesso!");
                }
                
            }
            catch(FileNotFoundException e) {
                msg_erro("Erro ao Carregar Nomes: " + e);
                alunos_nome.clear();
            }
            catch(IOException e) {
                msg_erro("Erro ao Carregar Nomes: " + e);
                alunos_nome.clear();
            }
            catch(ArrayIndexOutOfBoundsException e) {
                msg_erro("Erro ao Carregar Nomes: " + e);
                alunos_nome.clear();
            }
            catch(StringIndexOutOfBoundsException e) {
                msg_erro("Erro ao Carregar Nomes: " + e);
                alunos_nome.clear();
            }
        }
    }
    
    // Procura por ocorrências no ArrayList de Nomes para cada RM:
    private String retornar_nome(ArrayList<String> nomes, Integer rm) throws ArrayIndexOutOfBoundsException, StringIndexOutOfBoundsException {
        String nome_orig = String.valueOf(rm);
        String nome = nome_orig;
        if(!nomes.isEmpty()) {
            for(int k = 0 ; k < nomes.size() ; k++) {
                if(nomes.get(k).length() > 5 && nomes.get(k).substring(0,5).equals(nome)) {
                    if(nomes.get(k).length() > 8) {
                        nome = nomes.get(k).substring(8, nomes.get(k).length());
                    }
                }
            }
        }
        if(nome_orig.equals(nome)) {
            nome = "RM " + String.valueOf(rm);
        }
        
    return(nome);
    }
    
    
    /******************************
     * MÉTODOS - EXIBIÇÃO E LISTA *
     ******************************/
    
    // Lista os alunos e suas conexões:
    private void listar_alunos() {
        if(alunos_rm.isEmpty()) {
            msg_aviso("Carregue os Alunos primeiro!");
        }
        else {
            boolean continuar = true;
            // Nomes Foram Carregados:
            if(!alunos_nome.isEmpty()) {
                for(int k = 0 ; k < alunos_nome.size() && continuar ; k++) {
                    String mensagem = "Aluno: " + alunos_nome.get(k).getNome() + "\n\nConexões: ";
                    String[] conexoes_nome = alunos_nome.get(k).getConexoes_nome();
                    for(String s : conexoes_nome) {
                        if(!("".equals(s))) {
                            mensagem += s + " - ";
                        }
                    }
                    if(mensagem.substring(mensagem.length() - 3, mensagem.length()).equals(" - ")) {
                        mensagem = mensagem.substring(0, mensagem.length() - 3);
                    }
                    else {
                        mensagem += "Nenhuma";
                    }
                    String titulo = alunos_nome.get(k).getNome() + " (" + String.valueOf(k+1) + "/" + String.valueOf(alunos_nome.size()) + ")";
                    continuar = listar_alunos_exibir_dialogo(mensagem, titulo);
                }
            }
            // Nomes Não Foram Carregados:
            else {
                for(int k = 0 ; k < alunos_rm.size() && continuar ; k++) {
                    String mensagem = "RM: " + String.valueOf(alunos_rm.get(k).getRm()) + "\n\nConexões: ";
                    Integer[] conexoes_rm = alunos_rm.get(k).getConexoes_rm();
                    for(Integer i : conexoes_rm) {
                        if(i != 0) {
                            mensagem += "RM " + String.valueOf(i) + " - ";
                        }
                    }
                    if(mensagem.substring(mensagem.length() - 3, mensagem.length()).equals(" - ")) {
                        mensagem = mensagem.substring(0, mensagem.length() - 3);
                    }
                    else {
                        mensagem += "Nenhuma";
                    }
                    String titulo = String.valueOf(alunos_rm.get(k).getRm()) + " (" + String.valueOf(k+1) + "/" + String.valueOf(alunos_rm.size()) + ")";
                    continuar = listar_alunos_exibir_dialogo(mensagem, titulo);
                }
            }
            
        }
    }
    // Se clicar em "Cancelar", interrompe o laço
    private boolean listar_alunos_exibir_dialogo(String mensagem, String titulo) {
        Integer opcao = JOptionPane.showConfirmDialog(null, mensagem, titulo, JOptionPane.OK_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE);
        if(opcao == JOptionPane.CANCEL_OPTION) {
            return(false);
        }
        else {
            return(true);
        }
    }
    
    private void exibir_apontamentos() {
        if(alunos_rm.isEmpty()) {
            msg_aviso("Carregue os Alunos primeiro!");
        }
        else {
            String pesquisa = JOptionPane.showInputDialog("Digite o Nome ou RM: ");
            Aluno aluno = pesquisar(pesquisa); // Pesquisa o nome ou RM nos ArrayLists
            boolean is_rm = isRM(pesquisa); 
            if(aluno != null) { // Se ocorreu algum erro, o método pesquisar vai retornar o objeto aluno como null
                Popularidade p = new Popularidade(aluno);
                String mensagem = "Resultados da Busca - ";
                if(is_rm) {
                    if(alunos_nome.isEmpty()) { // Colocou um RM, não carregou os Nomes
                        mensagem += "RM " + String.valueOf(p.getAluno().getRm() + ":\n\n");
                        for(Aluno a : alunos_rm) {
                            Integer[] conexoes_rm = a.getConexoes_rm();
                            for(Integer i : conexoes_rm) {
                                if(i != 0 && i - p.getAluno().getRm() == 0) {
                                    mensagem += "RM " + String.valueOf(a.getRm()) + "\n";
                                    p.incr_apontamentos();
                                }
                            }
                        }
                    }
                    else { // Colocou um RM, carregou os Nomes
                        mensagem += p.getAluno().getNome() + ":\n\n";
                        for(Aluno a : alunos_nome) {
                            String[] conexoes_nome = a.getConexoes_nome();
                            for(String s : conexoes_nome) {
                                if(!("".equals(s)) && s.equals(p.getAluno().getNome())) {
                                    mensagem += a.getNome() + "\n";
                                    p.incr_apontamentos();
                                }
                            }
                        }
                    }
                }
                else { // Colocou um Nome
                    mensagem += p.getAluno().getNome() + ":\n\n";
                    for(Aluno a : alunos_nome) {
                        String[] conexoes_nome = a.getConexoes_nome();
                        for(String s : conexoes_nome) {
                            if(!("".equals(s)) && s.equals(p.getAluno().getNome())) {
                                mensagem += a.getNome() + "\n";
                                p.incr_apontamentos();
                            }
                        }
                    }
                }
                if(p.getApontamentos() == 0) {
                    mensagem += "Ninguém\n";
                }

                mensagem += "\nTotal de Apontamentos: " + String.valueOf(p.getApontamentos());
                JOptionPane.showMessageDialog(null, mensagem, "Busca: " + pesquisa, JOptionPane.INFORMATION_MESSAGE);
            }
        }
    }
    
    private Aluno pesquisar(String pesquisa) {
        Aluno aluno = null;
        if(pesquisa != null && (!("".equals(pesquisa)))) {
            boolean is_rm = false;
            // Digitou um número:
            if(isRM(pesquisa)) {
                is_rm = true;
                Integer rm = Integer.parseInt(pesquisa);
                System.out.println();
                sort.setAlunos_rm(alunos_rm);
                Integer index = sort.busca_binaria_alunos_rm(rm, 0, alunos_rm.size() - 1);
                if(index == -1) {
                    msg_aviso("RM " + String.valueOf(rm) + " não encontrado!");
                }
                else {
                    aluno = alunos_rm.get(index);
                }
            }
            // Não digitou um número:
            else {
                if(alunos_nome.isEmpty()) {
                    msg_aviso("Carregue os Nomes primeiro!");
                }
                else {
                    ArrayList<String> lista_nomes = new ArrayList<String>();
                    Integer cont = 0;
                    for(Aluno a : alunos_nome) {
                        if(a.getNome().toLowerCase().contains(pesquisa.toLowerCase())) {
                            if(cont < 10) {
                                if(lista_nomes.isEmpty()) {
                                    aluno = a;
                                }
                                lista_nomes.add(a.getNome());
                            }
                            else if (cont == 10) {
                                lista_nomes.add("...");
                            }
                            cont++;
                        }
                    }
                    if(lista_nomes.isEmpty()) {
                        msg_aviso("Nenhum resultado para: " + pesquisa);
                    }
                    else if (lista_nomes.size() > 1) {
                        String aviso = "Foram encontrados mais de um resultado. Por favor, refine a pesquisa:\n\n";
                        for(String s : lista_nomes) {
                            aviso += s + "\n";
                        }
                        msg_aviso(aviso);
                        aluno = null;
                    }
                }
            }
        }
        
    return(aluno);
    }
    
    private void listar_popularidade() {
        if(alunos_rm.isEmpty()) {
            msg_aviso("Carregue os Alunos primeiro!");
        }
        else {
            popularidade.clear();
            boolean rm = false;
            if(alunos_nome.isEmpty()) {
                rm = true;
                for(Aluno a : alunos_rm) {
                    popularidade.add(new Popularidade(a));
                }
            }
            else {
                for (Aluno a : alunos_nome) {
                    popularidade.add(new Popularidade(a));
                }
            }
            if(!popularidade.isEmpty()) {
                if(rm) {
                    for(Popularidade p : popularidade) {
                        for(Aluno a : alunos_rm) {
                            p.getAluno().setNome("RM " + String.valueOf(p.getAluno().getRm()));
                            Integer[] conexoes_rm = a.getConexoes_rm();
                            for(Integer i : conexoes_rm) {
                                if(i != 0 && p.getAluno().getRm() - i == 0) {
                                    p.incr_apontamentos();
                                }
                            }
                        }
                    }
                }
                else {
                    for(Popularidade p : popularidade) {
                        for(Aluno a : alunos_nome) {
                            String[] conexoes_nome = a.getConexoes_nome();
                            for(String s : conexoes_nome) {
                                if((!("".equals(s))) && s.equals(p.getAluno().getNome())) {
                                    p.incr_apontamentos();
                                }
                            }
                        }
                    }
                }
                System.out.println("\n\n# Popularidade dos Alunos: #\n");
                print.imprimir_popularidade(popularidade);
                Integer opcao = JOptionPane.showConfirmDialog(null, "Deseja Ordenar a Lista por Popularidade ao invés de Nome? ", "Questão", JOptionPane.YES_NO_OPTION);
                if(opcao == JOptionPane.YES_OPTION) {
                    sort.setPopularidade(popularidade);
                    long startTime = System.nanoTime();
                    sort.quicksort_popularidade(0, popularidade.size()-1);
                    long endTime = System.nanoTime();
                    float duracao = (endTime - startTime) / 1000000.0f;
                    popularidade = sort.getPopularidade();
                    System.out.println("\n\n# Alunos - Ordenados por Popularidade: #\n");
                    print.imprimir_popularidade(popularidade);
                    System.out.println("\n\n# Quick Sort - Duração: " + String.valueOf(duracao) + "ms (muitos valores iguais) #");
                    
                }
                int cont = 0;
                String mensagem = "Aluno[RM]: Popularidade:\n\n";
                for(Popularidade p : popularidade) {
                    cont++;
                    if(cont == 10) {
                        mensagem += p.getAluno().getNome() + "[" + String.valueOf(p.getAluno().getRm()) + "]: " + String.valueOf(p.getApontamentos() + "\n");
                        JOptionPane.showMessageDialog(null, mensagem, "Popularidade", JOptionPane.INFORMATION_MESSAGE);
                        mensagem = "Aluno[RM]: Popularidade:\n\n";
                        cont = 0;
                    }
                    else {
                        mensagem += p.getAluno().getNome() + "[" + String.valueOf(p.getAluno().getRm()) + "]: " + String.valueOf(p.getApontamentos() + "\n");
                    }
                }
                if(cont != 0) {
                    JOptionPane.showMessageDialog(null, mensagem, "Popularidade", JOptionPane.INFORMATION_MESSAGE);
                }
            }
        }
    }
    
    /*******************
     * MÉTODOS - GRAFO *
     *******************/
    
    private void exibir_conexoes_proximas() {
        if(alunos_rm.isEmpty()) {
            msg_aviso("Carregue os Alunos primeiro!");
        }
        else {
            String pesquisa = JOptionPane.showInputDialog("Digite o Nome ou RM: ");
            Aluno aluno = pesquisar(pesquisa);
            if(aluno != null) {
                boolean is_rm = false;
                if(alunos_nome.isEmpty()) {
                    is_rm = true;
                    Grafo gr = new Grafo();
                    gr.exibir_conexoes_proximas(is_rm, aluno, alunos_rm);
                }
                else {
                    Grafo gr = new Grafo();
                    gr.exibir_conexoes_proximas(is_rm, aluno, alunos_nome);
                }
            }
        }
    }
    
    private void exibir_menor_caminho() {
        if(g == null) {
            msg_aviso("Crie o Grafo primeiro!");
        }
        else {
            String pesquisa = JOptionPane.showInputDialog("Digite o Nome ou RM da Origem: ");
            Aluno aluno1 = pesquisar(pesquisa);
            if(aluno1 != null) {
                pesquisa = JOptionPane.showInputDialog("Digite o Nome ou RM do Destino: ");
                Aluno aluno2 = pesquisar(pesquisa);
                if(aluno2 != null) {
                    Grafo gr = new Grafo();

                    if(!gr.exibir_menor_caminho(grafo_rm, aluno1, aluno2, g)) {
                        msg_aviso("Não foi encontrado um caminho entre os dois alunos!");
                    }
                    
                    else {
                        JOptionPane.showMessageDialog(null, "Distância (nós): " + String.valueOf(gr.getDistancia()), "Informação", JOptionPane.INFORMATION_MESSAGE);
                    }
                }
            }
        }
    }
    
    private void listar_nao_alcancaveis() {
        if(g == null) {
            msg_aviso("Crie o Grafo primeiro!");
        }
        else {
            String pesquisa = JOptionPane.showInputDialog("Digite o Nome ou RM do Aluno: ");
            Aluno aluno = pesquisar(pesquisa);
            if(aluno != null) {
                Grafo gr = new Grafo();
                ArrayList<String> nao_alcancaveis;
                String aluno_nome;
                if(grafo_rm) {
                    nao_alcancaveis = gr.listar_nao_alcancaveis(grafo_rm, aluno, g, alunos_rm);
                    aluno_nome = "RM " + String.valueOf(aluno.getRm());
                }
                else {
                    nao_alcancaveis = gr.listar_nao_alcancaveis(grafo_rm, aluno, g, alunos_nome);
                    aluno_nome = aluno.getNome();
                }
                if(nao_alcancaveis.isEmpty()) {
                    JOptionPane.showMessageDialog(null, "Todos os alunos são alcançáveis por: " + aluno_nome);
                }
                else {
                    int index = 0;
                    String mensagem = "Alunos não alcançáveis por: " + aluno_nome + ":\n\n";
                    for(int cont = 0 ; cont < nao_alcancaveis.size() ; cont++) {
                        if(index < 10) {
                            mensagem += nao_alcancaveis.get(cont) + "\n";
                            index++;
                        }
                        else {
                            mensagem += nao_alcancaveis.get(cont) + "\n";
                            JOptionPane.showMessageDialog(null, mensagem, "Resultado", JOptionPane.INFORMATION_MESSAGE);
                            mensagem = "Alunos não alcançáveis por: " + aluno_nome + ":\n\n";
                            index = 0;
                        }
                    }
                    if(index != 0) {
                        JOptionPane.showMessageDialog(null, mensagem, "Resultado", JOptionPane.INFORMATION_MESSAGE);
                    }
                }
            }
        }
    }
    
    private void listar_qtde_maxima() {
        if(g == null) {
            msg_aviso("Crie o Grafo primeiro!");
        }
        else {
            String pesquisa = JOptionPane.showInputDialog("Digite o Nome ou RM do Aluno: ");
            Aluno aluno = pesquisar(pesquisa);
            if(aluno != null) {
                boolean continuar = true;
                Integer distancia = 0;
                try {
                    distancia = Integer.parseInt(JOptionPane.showInputDialog("Digite a distância: "));
                }
                catch(NumberFormatException e ) {
                    msg_aviso("Digite uma distância válida! (número inteiro)");
                    continuar = false;
                }
                if(continuar) {
                    if(distancia < 1) {
                        msg_aviso("Digite uma valor positivo e maior que 0!");
                        continuar = false;
                    }
                }
                if(continuar) {
                    Grafo gr = new Grafo();
                    ArrayList<String> aluno_distancia;
                    String aluno_nome;
                    
                    if(grafo_rm) {
                        aluno_distancia = gr.listar_qtde_maxima(grafo_rm, aluno, g, alunos_rm, distancia);
                        aluno_nome = "RM " + String.valueOf(aluno.getRm());
                    }
                    else {
                        aluno_distancia = gr.listar_qtde_maxima(grafo_rm, aluno, g, alunos_nome, distancia);
                        aluno_nome = aluno.getNome();
                    }
                    if(aluno_distancia.isEmpty()) {
                        JOptionPane.showMessageDialog(null, "Não há nenhum aluno que possa ser contactado!", "Resultado", JOptionPane.INFORMATION_MESSAGE);
                    }
                    else {
                        sort.setAluno_distancia(aluno_distancia);
                        long startTime = System.nanoTime();
                        sort.insertion_sort_aluno_distancia();
                        long endTime = System.nanoTime();
                        aluno_distancia = sort.getAluno_distancia();
                        float duracao = (endTime - startTime) / 1000000.0f;
                        System.out.println("\n# Aluno | Distância - Ordenados por Nome: #\n\n");
                        print.imprimir_aluno_distancia(aluno_distancia);
                        System.out.println("\n# Insertion Sort - Duração: " + String.valueOf(duracao) + " #\n");
                        
                        JOptionPane.showMessageDialog(null, "Quantidade Máxima: " + String.valueOf(aluno_distancia.size()), "Resultado", JOptionPane.INFORMATION_MESSAGE);
                        int index = 0;
                        int dist = 1;
                        String mensagem = aluno_nome + ": Aluno | Distância:\n\n";
                        for(int cont = 0 ; cont < aluno_distancia.size() ; cont++) {
                            if(index < 10) {
                                mensagem += String.valueOf(dist) + ". " + aluno_distancia.get(cont) + "\n";
                                index++;
                            }
                            else {
                                mensagem += String.valueOf(dist) + ". " + aluno_distancia.get(cont) + "\n";
                                JOptionPane.showMessageDialog(null, mensagem, "Resultado", JOptionPane.INFORMATION_MESSAGE);
                                mensagem = aluno_nome + ": Aluno | Distância:\n\n";
                                index = 0;
                            }
                        dist++;
                        }
                        if(index != 0) {
                            JOptionPane.showMessageDialog(null, mensagem, "Resultado", JOptionPane.INFORMATION_MESSAGE);
                        }
                    }
                }
            }
        }
    }
    
    private void criar_grafo_rm() {
        if(alunos_rm.isEmpty()) {
            msg_aviso("Carregue os Alunos primeiro!");
        }
        else {
            g = null;
            Grafo gr = new Grafo();
            g = gr.criar_grafo(true, alunos_rm);
            if(g != null) {
                System.out.println("\n\n# Grafo Gerado - RM's: #\n");
                print.imprimir_grafo(g);
                
                msg_sucesso("Grafo - RM's criado com sucesso!");
                
                grafo_rm = true;
            }
        }
    }
    
    private void criar_grafo_nome() {
        if(alunos_nome.isEmpty()) {
            msg_aviso("Carregue os Nomes primeiro!");
        }
        else {
            g = null;
            Grafo gr = new Grafo();
            g = gr.criar_grafo(false, alunos_nome);
            if(g != null) {
                System.out.println("\n\n# Grafo Gerado - Nomes: #\n");
                print.imprimir_grafo(g);
                
                msg_sucesso("Grafo - Nomes criado com sucesso!");
                
                grafo_rm = false;
            }
        }
    }
    
    private void exibir_grafo() {
        if(g == null) {
            msg_aviso("Crie o Grafo primeiro!");
        }
        else {
            Exibir_Grafo jn = new Exibir_Grafo(lista_rm, alunos_rm, alunos_nome, g, grafo_rm);
            jn.setVisible(true);
            this.dispose();
        }
    }
    
     /************************
     * MÉTODOS - JOPTIONPANE *
     *************************/
    
    private void msg_erro(String msg) {
        JOptionPane.showMessageDialog(null, msg, "Erro", JOptionPane.ERROR_MESSAGE);
    }
    
    private void msg_aviso(String msg) {
        JOptionPane.showMessageDialog(null, msg, "Aviso", JOptionPane.WARNING_MESSAGE);
    }
    
    private void msg_sucesso(String msg) {
        JOptionPane.showMessageDialog(null, msg, "Sucesso!", JOptionPane.INFORMATION_MESSAGE);
    }
    
    private boolean isRM(String aluno) {
        try {
            Integer rm = Integer.parseInt(aluno);
        }
        catch(NumberFormatException e) {
            return(false);
        }
        
    return(true);
    }
    
    public static void main(String args[]) {
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(Principal.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(Principal.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(Principal.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(Principal.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }

        java.awt.EventQueue.invokeLater(new Runnable() {

            public void run() {
                new Principal().setVisible(true);
            }
        });
    }
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JButton btnCarregarAlunos;
    private javax.swing.JButton btnCarregarArquivo;
    private javax.swing.JButton btnCarregarNomes;
    private javax.swing.JButton btnCarregarTudo;
    private javax.swing.JButton btnConexoes;
    private javax.swing.JButton btnExibirGrafo;
    private javax.swing.JButton btnGrafoNomes;
    private javax.swing.JButton btnGrafoRMs;
    private javax.swing.JButton btnListarAlunos;
    private javax.swing.JButton btnListarPopularidade;
    private javax.swing.JButton btnMenorCaminho;
    private javax.swing.JButton btnNaoAlcancaveis;
    private javax.swing.JButton btnPesquisarApontamentos;
    private javax.swing.JButton btnQtdeMax;
    private javax.swing.JButton btnSair;
    // End of variables declaration//GEN-END:variables
}
